Software products that are installed in the field can become outdated or can contain bugs. Software companies will often provide software patches for their products that update the product's functionality or fix bugs found in the field. The patch is usually a software package that, when applied to the software product, modifies the installed software product in some way, but does not completely reinstall the software product. Sometimes a software product will require a series of patches that provide a series of updates or fixes. For example, a software company may provide a patch that updates a key feature of a software product. A few months later the software company may discover a security hole caused by the update, and will subsequently release another patch that closes the security hole. A software product may require many patches over the course of its product life, especially if the software product is complex or has a long product life.
Software patches may be dependent upon previously released software patches. For example, where two software patches modify one or more files, one software patch may be a pre-requisite for another software patch, meaning that the two software patches modify one or more of the same files. That is, there is an overlap between the two sets of files modified by the two patches. Pre-requisite dependencies are relatively easy to detect by the software company that produces the patch because they can be detected by comparing the files that were modified by the two patches.
Other software patch dependences, however, can be harder to detect. It is possible that the set of files modified by two software patches may be entirely different and have no overlap, but the second software patch still requires the first software patch to be installed in order to function correctly. For example, the first software patch may change a method's or function's signature, or the way a method or function works. The second patch may rely on the modification. Since the first software patch was not installed, the modification upon which the subsequent patch relies is not present in the system. Without the modification the subsequent patch may not work properly or may crash the system. In this scenario, the first patch may be referred to as a co-requisite of the second patch. The dependency may be more difficult to notice: it may not be detectable until the subsequent patch has been installed on the system, has relied on the modification which is not present, and fails to work or crashes the running system. Co-requisite software patch dependencies can be very difficult to detect by the software company that produces the patch and, if not detected, can often cause system crashes or functional failures in the field.